好的，让我们开始编写 IFB 信号管理的代码。
OK, so let's start writing the code for our IFB signal management.

这里。
Here.

所以请记住，我们打算处理的每个信号都会调用 FBI。
So remember, this, FBI is called for every signal that we intend to process.

所以实际上我们需要检测何时有一个新信号刚刚被激活。
So actually we need to detect that when there is a new signal that has just been activated.

假设这是一个警报，警报，故障就会发生。
Let's say that this is an alarm and the alarm, the fault is just to happen.

我们还需要检测何时需要重置已激活的信号。
And we also need to detect when we need to reset a signal that was already activated.

因此，为了检测是否有新信号，我们需要激活 FBI 输入的实际信号。
So in order to detect that we have a new signal, we need to have the actual signal active of the input of the FBI.

然后我们还应该跟踪哪些信号是活动的，以便这样做，让我们创建一个变量抱歉，让我们在这里创建一个变量，它应该是一个布尔变量数组，我们将其称为活动信号将在数组中。
Then we should also take track of which signals are active in order to do so, let's create a variable sorry, let's create a variable here that should be an array of boolean variables that we will call active signals will be in array.

我们在这里说过，在我们的信号列表中，我们最多可以有 20 个当代信号处于活动状态。
We said here that in our signal lists here that we can have up to, uh, 20, uh, contemporary signals active.

但在这里我们可以允许配置和处理更多数量的信号。
But here we can allow a bigger number of signals to be configured and processed.

因此，我们现在可以允许最多 1000 个信号，这并不意味着，呃，1000 个 Allama 亲戚是活跃的。
So let's say for now that we can allow up to 1000 signals that this does not mean, uh, 1000 Allama relatives active.

同时，我们正在讨论具有独特想法的信号，该信号将由函数look处理。
At the same time, we are talking about the signals with a unique idea that will be processed by the function look.

所以在这里我们会说，如果我们有信号活动，但我们没有与我们现在正在处理的信号想法相对应的活动信号布尔变量。
So here we will say that if we have signal active and we do not have the active signal boolean variable corresponding to the signal idea that we are processing now.

在这种情况下，这意味着我们有一个新的。
In this case, this means that we have a new.

活动信号，这意味着我们有一个尚未处理的信号，因此为了做到这一点，我们首先要激活该信号，这意味着我们需要记住我们刚刚处理了这个信号。
Active signals, that means that we have a signal that we haven't already processed, so in order to do so, let's first of all activate the signal, meaning that we need to remember that we just processed this.

所以我们的信号它的信号ID应该等于二。
So our signal of its signal ID should be equal to two.

实际上，这里我们正在处理多达 1000 个、多达 1000 个可能的信号，从 1 到 1000。
Actually, here we are processing up to 1000, up to 1000 possible signals from one to 1000.

实际上，我们不能允许 I.D. 这样的信号超出此范围。
We actually cannot allow an I.D., a signal like the that is outside of this range.

因此，如果信号 ID 小于 1 或信号 ID 大于 1000，情况就是如此。
So that's right here that if the signal ID is lower than one or the signal ID is bigger than one thousand.

或者我们也可以说信号类型是none，因为如果我们无法处理none 类型的信号或等于none 的信号类型，那么我们应该返回。
Or let's also say that the signal type is none, because if we cannot process a none type of signal or signal type equal to none, then we should return.

功能块不应执行任何操作，因为插入的值不正确。
The function blocks shouldn't do anything because the values inserted are not correct.

所以我们在这里处理信号。
So here we are processing the signal.

这意味着新信号已添加，因此需要将其添加到列表中。
This means that the new signal has been added that so it needs to be added on the onto the list.

因此，我们首先需要更新活动信号的数量。
So let's first we need to update the number of active signals.

因此，在我们的信号列表中，正如您所记得的那样，我会将其放置在信号列表的右侧。
So in our signal list, as you remember here, I would place it here on the right in our signal list.

我们有很多不同的数字来告诉我们有多少信号是活跃的。
We had a number that many different numbers that tells us how many signals are active.

那么我们首先需要做什么，因为我们有一个新信号，所以我们需要有信号表明活动信号的数量应该增加一个。
So what we need to do first, since we are having a new signal, we need to have signal that number of active signals should be increased by one.

所以信号是活动信号的数量加一。
So signal is that number of active signals plus one.

然后，根据。
Then, according to the.

信号类型，我们要做不同的事情。
Type of signal, we shall do different things.

意思是如果信号是警报，我们需要增加警报、警报数量，如果是警告，我们需要增加警告数量。
Meaning that if the signal is an alarm, we need to increase the alarm, the alarm number, if it is a warning, we need to increase the number of warnings.

而如果是消息，我们就需要增加消息的数量。
And if it is a message, we need to increase the number of messages.

因此，让我们根据信号类型在这里创建一个案例。
So let's create a case over here based on the signal type of.

那么如果信号类型是警报。
So if the signal type is an alarm.

我们需要增加警报的数量，所以。
We need to increase the number of alarms, so.

在这里，我将复制这一行，抱歉，并且。
Here, I will copy this line, sorry, and.

此行应该会增加活动警报的数量。
This line should increase the number of active alarms.

在这里，所有时间也是如此。
And here as well, all hours, the same goes for the.

警告我们需要增加主动警告的数量。
Warning we need to increase the number of active warnings.

再次强调，如果这是一条消息。
Again, here and for if it is a message.

警告和警告。
Warnings and warnings.

我们需要增加活跃消息的数量。
We need to increase the number of active messages.

这里也是如此，然后这里，到目前为止，我们实际上成功地正确更新了这四个变量，然后我们需要管理。
And the same goes here, then here, up to this point, we managed to actually update these four variables correctly, then we need to manage the.

列出列表本身。
List the list itself.

所以我们需要做的是，当我们添加一个新的阿拉玛、一个新的信号时，我们需要改变。
So what we need to do is when we add a new allama, a new signal, we need to shift.

好吧，首先，我们需要决定抱歉，我们需要在哪个索引处放置警报，即列表中的信号，所以让我们在这里创建变量，即所谓的变量。
Well, first, we need to decide sorry, at which index we need to place the alarm, the the signal in our list, so let's create variable here, that is called.

新信号索引，这将是我们列表中放置新消息的索引，并且应该根据我们的信号类型而有所不同。
New signal index, this will be the index in our list where we will put our new message and should be different according to what type of signal we are.

正如您所记得的，我们希望将紧急情况放在列表的顶部，然后是警告，然后是消息。
So as you remember, we wanted to place at the top of our list the emergency emergencies, then the warnings and then the messages.

所以。
So the.

如果我们收到新的警报或应该放置新的警报，实际上是这样。
That if we get a new alarm or the new alarms should be placed, it actually.

在.
At the.

不，我们刚刚更新了信号列表、活动警报的数量，所以让我们看看我们已经有三个活动警报了。
No, that we just updated it up, the signal list, that number of active alarms, so let's see that we have three alarms already active.

我们得到新的信号，因此该数字将更新为 4，因此新信号的索引将需要为 4。
We get to new one, so this number will get updated to four and therefore the index of our new signal will need to be four.

在这里，对于警告，我们需要将其推到警告列表的末尾，因此，如果我们收到新警告，我们可以说我们有四个，例如，三个警报处于活动状态，四个警告处于活动状态。
Here instead for the warnings, we need to push it at the end of the warning list, so if we get a new warning, we let's say that we have four, for instance, three alarms active and four warnings active.

如果我们得到新的，我们需要将其放置在索引 8 处。
If we get the new one, we will need to place it at index eight.

所以。
So.

我们将对此进行辩论，这将变成五，下一个将需要是这个数字加上这个数字，所以三加五。
We will debate this and this will become five, and the next will need to be this number plus this number, so three plus five.

因此，我们警告的新信号索引将是。
So the new signal index for our warnings will be.

活动警报的数量加上活动警告的数量。
The number of active alarms plus the number of active warnings.

好的，那么，对于我们的消息，我们需要做同样的事情，这意味着我们需要将它实际添加到所有内容的末尾。
OK, then, for our messages, we need to do the same thing, meaning that we need to actually add it at the end of everything.

因此，活动警报的数量加上活动警告的数量，加上活动消息的数量，即为活动信号的数量。
So the number of active alarms plus the number of active warnings, plus the number of active messages, that is just the number of active signals.

因此对于消息来说，新的信号索引是。
So for the messages, the new signal index is.

活动信号数表示活动信号的数量。
The number of active signals signals that the number of active signals.

好的，到目前为止我们已经检测到了八个，这表明我们需要放置新信号。
OK, so up to now we have detected eight, which indicates we need to place the new signal.

为了达纳。
In order to Dana.

我们需要做什么。
What we need to do.

就是要转移。
Is to shift.

一个位置下面的所有信号，因为在插入之前，我们需要将所有信号按我们的单位向下移动。
All the signals below it of one position, because before inserting, we need to shift everything down by our unit.

所以我这里要写的是，我们需要为一个循环写一个for循环。
So what I will write here is that we need to write a for loop for a loop.

我们需要一个用于 for 循环的索引变量。
We need an index variable for the for loop.

所以我会为你创造今年。
So I will create this year for you.

有一个索引您分配无符号整数索引。
There is an index you assign unsigned integer index.

因此，对于签名的抱歉，等于您现在需要移动的索引。
So for the signed sorry, the index equal to you need to shift right now.

我们没有对列表进行任何修改。
We didn't make any modification to the list.

因此，根据我们检测到的新信号索引，我们需要将它们全部下移。
So from the new signal index that we that we detected, we need to shift all of them down.

但我们实际上需要从列表的底部开始。
But we actually need to start from the bottom of the list.

假设我们需要将所有信号从索引 5 移至索引 10。
So let's say that we need to shift all the signals from index five to ten.

我们需要从第十个开始并将其向下移动。
We need to start from the tenth one and move it down.

因此，为了做到这一点，我们需要向后执行一个 for 循环。
So in order to do so, we need to do a for loop going backward.

为此，我们需要从顶部数字开始。
In order to do so, we need to start from the top number.

所以我们需要对信号执行此操作。
So we need to do this for the signals.

因此对于索引信号来说，活跃信号的数量。
So for indexical to signal that the number of active signals to.

我们实际的新信号是我们选择加一，因为现在我们正在感受所有新的指数。
Our actual new signaling is that we chose plus one, because right now we are feeling all the new indexes.

因此，如果我们在处理此代码时有 10 个活动信号，那么我们将得到 11 个。
So if before we had 10 active signals when we processed this code, we get to eleven.

所以我们需要更新从11开始的所有索引。
So we need to update all the indexes from 11.

到新的我们检测到的新信号索引。
To the new the new signal index that we detected.

并以此来进行for循环。
And in order to carry out the for loop.

呃，从，呃，更大的数字到更小的数字，我们需要在这里插入我们想要采取的步骤的维度。
Uh, from the, uh, bigger number to a smaller one, we need to insert here by and the dimension of the step that we want to take.

所以在这里我将减一。
So here I will right by minus one.

这样我们，呃，我们将从较大的数字二开始，较小的数字开始。
The and this way we, uh, we will start from the bigger number two, the smaller one.

我们将采取减一的步骤。
And we will take steps of minus one.

然后，为了，呃，移位，我们只需要有信号列表，索引的活动信号应该等于索引减一的活动的、非活动信号的信号列表。
Then in order to, uh, shift, we just need to have the signal list, active signals of index that should be equal to signal a list of active, not active signals of index minus one.

通过这种方式，我们将阵列中的所有信号移动一个位置。
In this way, we are shifting all the signals by one place in the array.

因此，五号将被放置在六号中。
So number five will be placed in the number six.

六号将被放入七号中，依此类推。
Number six will be placed into number seven and so on.

但我们实际上是从底部开始，从最后一个萨尔瓦多开始，因为否则我们就会覆盖一切。
But we are actually starting from the bottom, from the from the last Salvadore, because otherwise we would be overwriting everything.

所以这会给我们留下一个整体。
So this this will leave us with a whole.

这需要填充我们的实际信号。
That needs to be filled with our actual signal.

所以在这里。
So here.

这将会出现，您说我们将在新信号之后重新排序列表，然后我将在这里写下，我需要将此信号添加到我们计算出的正确索引中的列表中，该索引现在对我们来说是免费的。
This will come and you're saying that we will reorder list after the new signal and then here I will write that I will need to add this signal to the list in the correct index that we computed that is now free for us.

那么我会写什么。
So what I would write.

是的，我确实会感受到这个指数。
Yes, I will actually feel that index.

因此，正确的信号列出的活动信号通常位于我们计算的不是新信号索引的位置。
So the right signal lists that active signals often at the position that we computer that is not new signal index.

因此，我们将使其信号名称等于输入的信号名称。
So we will have its signal name to be equal to the signal name input.

在我们的函数中，看，现在，我将复制这部分，其信号 ID 等于输入信号 ID，我们将再次获得该信号，信号类型等于信号类型。
In our function, look, now, I will just copy this part with its signal ID equal to the input signal ID, we will have the signal again, the signal type equal to the signal type.

也就是说，输入和活动字段需要设置为等于 3。
That is the input and the active field will need to be set equal to three.

然后我们需要听到的另一件事是记住在哪个位置。
Then another things that we need to hear is to remember in which position.

这是放置的信号吗？
Was this the signal placed?

因此，在这里我们将创建一个新变量，我们将其称为列表中的信号索引的新数组，并且该数组将是一个包含 1 到 1000 个无符号整数的数组。
So here we will create a new variable that we will call a new array that we call a signal index is in the list and will be an array that goes from one to 1000 of unsigned integers.

我们只需将这个索引写在信号处，手机，你就是信号源的索引列表中。
And we will simply write this index at the signal, the cell phone, you are a source of signal indexes in the list of.

您收到的信号将是我们新的信号索引。
You have signal it will be our new signal index.

当我们需要重置信号时，这个数组实际上是必要的，因此这对于我们在重置发生时重新排序列表非常有用。
This array will actually be necessary later on when we need to reset the signals, so this will be very useful for us to out to reorder the list when whenever reset occurs.

但现在请记住，我们只是放置我们刚刚关联的信号。
But for now here and remember, we are just placing we are just relating the signal already.

信号所在位置位于活动信号列表中（如果该信号处于活动状态）。
To where to where the signal is is in the list of active signals, if it is active.

好的，现在，我们构建了功能块，我们至少应该能够测试信号的激活。
OK, so for now, we built off of the function block and we should be able at least to test the activation of the signal.

因此，在这里让我们创建一些调用来测试它。
So here let's create, let's say, a few calls to test it.

所以我会在主程序中复制几次。
So I will copy this a few times in the main program.

让我们用不同的警报来称呼它。
Let's call this with different alarms.

看，我们有很多不同的消息。
See, we have a lot of different messages.

信号。
Signals.

抱歉，我拿到了。
Sorry, I got them.

一、三、警报二、警报三。
One, three, alarm two and alarm three.

现在就这样设置了，旧的重置，即使我们没有彻底使用它。
That's set for now, the old reset, even if we are not using it through, through and through.

然后让我们，呃，让我们复制树，对不起，呃，对不起，让我们复制一个树三次，然后创建三个警告。
Then let's do, uh, let's copy tree, I'm sorry, uh, sorry, let's copy one three times and let's create three warnings.

假设我们有一个警告，一个警告。
Let's say that we have a warning, one that is a warning.

让我们将其以及信号类型复制到此处。
Let's copy this down here, as well as the signal type.

我们来听听。
Let's hear.

警告至。
Warning to.

和。
And.

警告三。
Warning three.

并执行相同的操作以获得三条消息，因此此地毯是三次，这里最多有九行，对此表示抱歉。
And do the same for in order to have three messages, so this carpet is three times, you have up to nine lines here, will call this sorry.

留言一.
Message one.

这里。
Here.

像这样。
Like this.

这是作为信号类型的消息。
That is a message as the type of signal.

消息通过消息三，所以我只是设置消息，只是信号类型和这里的消息。
Message through a message three, so I just set down the message, just the signal type and right here message to.

还有第三条消息。
And of message three.

好的，让我们尝试上网。
OK, so let's try to go online.

我们还没有开发涉及重置的部分，所以如果我们的列表感觉像我们想要的那样，我们是否可以下载并查看列表？
We haven't already developed the part that concerns the reset, so let's can we have to download and see a list if our list feels as we want to?

那么让我们在右侧打开它。
So let's open it here on the right.

我会。
I will.

展开和。
Expanded and.

还扩展了一些信号。
Also expand some of the signals.

现在，我们没有警报，没有激活信号等等，所以让我们激活吧。
So right now, we have no alarms, no signal active and so on, so let's activate.

呃哦，不，抱歉，我想我们需要做另一件事。
Uh oh, no, sorry, I guess we need to do another thing.

因为不是为了多次调用，所以我们需要在这里有多个音量变量，所以让我们创建一个信号数组，抱歉我们会调用信号，对吧。
Because not for multiple calls, we need to have multiple volume variables here, so let's create an array of signals sorry that we would call signals, right.

假设有 1 到 10 个布尔变量。
Let's say that goes from one to 10 of boolean variables.

让我们在这里放置一个信号的信号。
And let's place here signal of one signals.

一个，然后在这里我们将播放两个信号，依此类推。
Of one, then here we will play signals of two and so on.

这是为了正确测试它。
This is in order to test it correctly.

这是一家相当有基础的公司。
It's quite a company based.

嗯，作业。
Um, assignment.

我会做的。
I will do this.

如果您需要的话，我可以尽快发布视频以供您了解。
As fast as I can about you can post the video to catch up if you need to.

好的。
OK.

七点的信号，我快完成了。
Signals of seven, I'm almost done.

我想我是
I guess I.

呃，我忘了一个。
Uh, I forgot one.

是的，所以这就是这里。
Yeah, so this was here.

六零七已过，是年，九的信号是耳。
Six zero seven was ere, it was year and signals signals of nine was ear.

好吧，对此感到抱歉。
OK, sorry for that.

现在正在进行下载。
Now carrying out a download.

在这里我们可以激活呼叫。
Here we can activate the call.

因为，呃，我将在这里独立地公开全局变量列表。
Because, uh, independently I will openness here, the global variable lists.

并扩大全球信号系统，所以在这里，如果我说第一个要通过。
And expand the global signal system, so here, if I said the first one to through.

我希望听到一个新的警报来忍受这个描述，并且警报活动变得等于 true，警报数量等于 1。
I expect to hear a new alarm to put up with this description and the alarm activity to become equal to true with numbers of alarm equal to one.

好吧，很抱歉，我们还没有管理这个，但是让我们离线，这很简单，很简单的事情。
OK, we're sorry, we're not managing this still, but let's go offline, and it is quite simple, quite a simple thing to do.

我们只需要在信号列表中将警报激活就等于警报数量大于零的事实。
We just need to right here in our signal list that that the alarms active is equal to the fact of having a number of alarms bigger than zero.

因此，我将简单地等待信号列表大于零的活动警报的数量。
So I will simply wait right to signal list the number of active alarms, bigger than zero.

消息和警告也是如此。
And the same goes for messages and warnings.

事实上，我们有一些活跃的警告。
So the fact that we have some warnings active.

等于具有多个主动警告的条件。
Is equal to the condition of having a number of active warnings.

大于零，抱歉，这是警告。
Bigger than zero, sorry, this was warning's.

和消息。
And messages.

消息。
Messages.

好的，如果我执行的话，我会再次向您展示。
OK, I will show you again if I carry out the.

全局语言，我将把它放在这里并进入我们的主要程序，并再次扩展它。
The global verbalised, I would place it here and go into our main program and would expand it once again.

名单，抱歉。
The list, sorry.

和。
And.

如果我按下此处，我会在位置一处收到一个警报，并且警报已激活，因为我们有一个警报。
If I press through here, I get one alarm here in position one and the alarm active is through because we have one alarm.

好的，如果我们进入 IFB。
OK, and if we get into our IFB.

信号索引位于我们创建的数组的各层中，将其置于第一位置。
The signal index is in layers to the array that we created will have it position one.

下一个，因为我们在第一位置有一个拉蒙。
The next one, because we have a Lamon at position one.

好的，让我们添加创建，现在让我们在此处添加警告。
OK, so let's add create and now let's add a warning here.

如果我激活此警告，它应该会在第二个位置弹出。
If I activate this warning, it should pop up at the second position.

我需要看到警告、控制和 F7 数量的增加。
And I need to we need to see increasing the number of warnings, control and F7 here.

你知道，对于奥基来说。
You know, for Ocky.

我猜有什么东西不起作用。
I guess that something isn't working.

让我看看为什么。
Let me see why.

我是否放置了否。
Did I place no.

好的，我没有更改唯一 ID，所以我们再次抱歉。
OK, I didn't change the unique I.D., so let's do this sorry again here.

让我们改变这一点。
Let's change this.

三。
Three.

四个、五个等等，因为我们不能接受相同ID的信号，八个、九个、六个，上线，这个就可以了。
Four, five and so on, because we cannot accept signals with the same I.D., eight, nine, six, go online, that this will work.

此外，我们还进行了简单的在线更改。
Also, we done a simple online change.

和。
And.

如果我现在去全球口头表达。
If I go to the global verbalised now.

现在我们已经得到了我们需要的东西，正如你所看到的。
Now we have what we need wanted, as you can see.

我们警告 Akst 警告活动等于 true，有两个信号，一个是警报，一个是第一个位置的警告。
We're warning Akst warnings active equal to true with two signals, which one is an alarm and one is a warning in the first position.

我们仍然将警报置于第二位置。
We still have the alarm in the second position.

我们有警告。
We have the warning.

如果我现在在 FBI 的左侧查看列表中的信号，我会期望找到位置的索引。
And if I look right now in the left, in the FBI at the signal in the list, I would expect to find out index for position to.

是的，因为第四个信号，信号，四个也都放在了位置上。
Yes, because the fourth signal, the signal, the four is placed on position, too.

好的。
OK.

因此，让我们尝试添加一条消息来表示此处的七到此处的七，您可以看到该消息在第三个位置弹出。
So let's try to add a message just to signal seven here to of seven here, you can see the message popping up at the third position.

现在让我们尝试添加一个新的闹钟。
And let's now try to add a new alarm.

如果我们是新警报，我们不会希望位于第一个警报下方的位置。
If if we are the new alarm, we won't want to be positioned in a position to just below the first one.

并且警告消息应该下降一位。
And the warning messages should be shipped down by one position.

因此，让我们启动警报以听到控制和七个。
So let's activate alarm to hear control and of seven.

正如您所看到的，警报在这里弹出，并显示警告和消息。
And as you can see, the alarm popped up here with the warning and the message.

只是简单地被转移了。
Simply were simply shifted.

在一个位置，但现在我们会看到实际上存在一个问题，因为在这里您会看到我们有两个信号。
By one position, but right now we will see that there is actually one problem, because here you will see that we have two signals.

根据这个变量，只需在列表中用相同的索引发出信号，因此我们需要在此处添加一个小修正，因为此信息是错误的。
Just signal with the same index in the list, according to this variable, so we need to add a small correction here because this information is wrong.

我们也应该有一个。
We should have one, too.

在这里我们需要三个和四个。
And here we would need to have three and four.

所以我们需要对此进行管理。
So we need to manage this.

当我们换班的时候。
When we shift.

我们需要更新这里的信号。
The signals are here we need to update.

这个山谷就在这里，对吗？
This valley is so here are we right?

这是相当棘手的，所以我需要你和我一起关注这里的信号索引。
This is quite tricky, so I need you to hang with me signal indexes in this.

的。
ofThe.

我们需要改变。
We need to change the.

这个数组的值对应于我们刚刚移动的位置。
The value of this array at the position that corresponds to the idea that we just moved so.

这个想法是在这个变量中，信号，即......
The idea is in this variable here that the signal, i.e..

右括号，这应该等于我们刚刚更改的索引。
Closing brackets, and this should be placed equal to the index that we just changed.

我知道这是这段代码中相当棘手的部分，但如果你仔细想想，它是如此索引，这是有道理的，因为我们只是在移动。
I know this is a quite tricky part of this code, but if you think about it, it so indexes, it makes sense because we are just moving.

我们正在更新列表，让我们注意到什么是索引？
We are we are updating the list that allows us to take note of what is the index?

对应于信号化，因此由于我们通过执行此移位来更改索引，因此我们需要更新变量，添加具有新索引的信号 IDL。
Corresponding to the signalized, so since we are changing the index by carrying out this shift, we will need to update the variable, add the signal IDL with a new index.

因此，如果我们上网并执行与出去下载之前相同的操作。
So if we go online and do the same thing that we did before going out to download.

现在，我们将看到尼克斯处于正确的位置，所以让我们进入主要部分，这就是我在激活警报一、激活警告一和激活消息一之前所做的事情。
Right now, we will see the Nix's in the correct position, so let's go into the main and that's what I did before I activated alarm one, I activated warning one and I activated message one.

我又回到了这里的全球名单。
And my getting back at the global list here.

我明白了。
I get this.

如果我添加一个新闹钟。
And if I add a new alarm.

有了这个。
With this.

这种转变发生了，我希望在内部 A 中看到这种转变。
The shift occurs and I expect to see in the internal A.

在第一个，我预计会看到一个，在第二个，我预计会看到两个，在第四个，我预计会看到三个，第七个，我预计会看到四个。
At the first one, I expect to see one and the second one I expect to see two at the fourth, the one I expect to see three and that the seventh one, I expect to see four.

那么让我们看看它是否有效。
So let's see here if it works.

一、二、三，71 票。
One, two, three, and at 71 vote.

好的，这是正确的，因为它们实际上已经更新了。
OK, this is correct, because they have been actually updated.

因此，我将添加另一个阿拉玛，我预计这将增加到四个和五个。
So I will add another Allama and I expect this to increase to become four and five.

我启动了你的警报，是的，这已经变成了四个，这已经变成了五个，好的，所以我们可以设法实现添加警报的部分，所以我们将信号添加到我们的列表中。
I starting your alarm and yes, this has become four and this has become five, OK, so we can manage to implement the part in which we add alarms, so we add signals to our list.

在下一个视频中，我们将了解如何编写代码来删除它们以重置它们。
In the next video, we will see how to write the code to remove them in order to reset them.

我知道这部分代码相对于我们之前所做的来说相当棘手，但是我们正在开发的这个组件对于您的所有项目以及我们的课程项目都将非常有用。
I know that this part of code is quite tricky with respect to what we did before, but this component that we are developing will be quite useful for you in all your projects and for us in our course project.